package com.tennis.tennisreservation.controller;

import com.tennis.tennisreservation.common.Result;
import com.tennis.tennisreservation.entity.Order;
import com.tennis.tennisreservation.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 订单控制器
 * 处理订单相关的请求
 */
@RestController
@RequestMapping("/api/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    /**
     * 创建订单
     * @param order 订单信息
     * @return 创建结果
     */
    @PostMapping("/create")
    public Result<?> createOrder(@RequestBody Order order) {
        try {
            // 输出接收到的订单数据，帮助调试
            System.out.println("接收到订单数据: " + order);
            
            // 检查时间冲突
            if (orderService.checkTimeConflict(order.getCourtId(), order.getStartTime(), order.getEndTime())) {
                System.out.println("时间冲突");
                return Result.fail("该时段已被预约，请选择其他时间");
            }
            
            Order createdOrder = orderService.createOrder(order);
            System.out.println("创建订单成功: " + createdOrder.getId());
            return Result.success(createdOrder);
        } catch (Exception e) {
            System.out.println("创建订单失败: " + e.getMessage());
            e.printStackTrace();
            return Result.fail("创建订单失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取订单列表（分页）
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @param userId 用户ID（可选）
     * @param keyword 关键词（可选）
     * @param payStatus 支付状态（可选）
     * @param status 订单状态（可选）
     * @param startTime 开始时间（可选）
     * @param endTime 结束时间（可选）
     * @return 订单列表
     */
    @GetMapping("/list")
    public Result<?> getOrderList(
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestParam(required = false) Long userId,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String payStatus,
            @RequestParam(required = false) String status,
            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime startTime,
            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime endTime) {
        
        Map<String, Object> data = orderService.getOrderList(
                pageNum, pageSize, userId, keyword, payStatus, status, startTime, endTime);
        
        return Result.success(data);
    }
    
    /**
     * 根据ID获取订单详情
     * @param id 订单ID
     * @return 订单详情
     */
    @GetMapping("/{id}")
    public Result<Order> getOrderById(@PathVariable Long id) {
        Order order = orderService.getOrderById(id);
        
        if (order != null) {
            return Result.success(order);
        } else {
            return Result.fail("订单不存在");
        }
    }
    
    /**
     * 根据用户ID获取订单列表，支持筛选
     * @param userId 用户ID
     * @param payStatus 支付状态（可选）
     * @param status 订单状态（可选）
     * @return 订单列表
     */
    @GetMapping("/user/{userId}")
    public Result<List<Order>> getOrdersByUserId(
            @PathVariable Long userId,
            @RequestParam(required = false) String payStatus,
            @RequestParam(required = false) String status) {
        
        // 先获取用户的所有订单
        List<Order> orders = orderService.getOrdersByUserId(userId);
        
        // 如果指定了支付状态，进行筛选
        if (payStatus != null && !payStatus.isEmpty()) {
            orders = orders.stream()
                    .filter(order -> payStatus.equals(order.getPayStatus()))
                    .collect(Collectors.toList());
        }
        
        // 如果指定了订单状态，进行筛选
        if (status != null && !status.isEmpty()) {
            orders = orders.stream()
                    .filter(order -> status.equals(order.getStatus()))
                    .collect(Collectors.toList());
        }
        
        return Result.success(orders);
    }
    
    /**
     * 取消订单
     * @param id 订单ID
     * @return 取消结果
     */
    @PostMapping("/cancel")
    public Result<String> cancelOrder(@RequestParam Long id) {
        boolean cancelled = orderService.cancelOrder(id);
        
        if (cancelled) {
            return Result.success("订单已取消，记录已标记为已取消状态");
        } else {
            return Result.fail("订单取消失败，未找到订单");
        }
    }
    
    /**
     * 更新订单支付状态
     * @param paymentInfo 支付信息(id, payStatus, couponId)
     * @return 更新结果
     */
    @PostMapping("/pay")
    public Result<?> updatePayStatus(@RequestBody Map<String, Object> paymentInfo) {
        try {
            Long id = Long.valueOf(paymentInfo.get("id").toString());
            String payStatus = paymentInfo.get("payStatus").toString();
            Long couponId = paymentInfo.get("couponId") != null && !paymentInfo.get("couponId").toString().equals("null") ? 
                            Long.valueOf(paymentInfo.get("couponId").toString()) : null;
            
            // 更新订单状态并处理红包
            Order order = orderService.updatePayStatusWithCoupon(id, payStatus, couponId);
            return Result.success(order);
        } catch (Exception e) {
            return Result.fail("更新支付状态失败：" + e.getMessage());
        }
    }
    
    /**
     * 余额支付接口
     * 接收用户余额信息，更新订单状态为已支付，同时更新用户余额
     * @param paymentInfo 支付信息，包含userId, orderId, giftBalance, rechargeBalance, couponId(可选)
     * @return 支付结果
     */
    @PostMapping("/balance-pay")
    public Result<?> balancePay(@RequestBody Map<String, Object> paymentInfo) {
        try {
            // 打印收到的参数，便于调试
            System.out.println("余额支付接收参数: " + paymentInfo);
            
            // 提取必要参数
            Long userId = Long.valueOf(paymentInfo.get("userId").toString());
            Long orderId = Long.valueOf(paymentInfo.get("orderId").toString());
            String giftBalance = paymentInfo.get("giftBalance").toString();
            String rechargeBalance = paymentInfo.get("rechargeBalance").toString();
            
            // 获取状态，默认为"used"
            String status = paymentInfo.containsKey("status") ? 
                            paymentInfo.get("status").toString() : "used";
            
            // 可选参数：红包ID
            Long couponId = null;
            if (paymentInfo.containsKey("couponId") && paymentInfo.get("couponId") != null && 
                !paymentInfo.get("couponId").toString().equals("null")) {
                couponId = Long.valueOf(paymentInfo.get("couponId").toString());
            }
            
            // 调用服务层方法处理余额支付，传递status参数
            boolean success = orderService.processBalancePayment(
                orderId, userId, giftBalance, rechargeBalance, couponId);
                
            if (success) {
                return Result.success("余额支付成功");
            } else {
                return Result.fail("余额支付失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.fail("余额支付失败: " + e.getMessage());
        }
    }
    
    /**
     * 根据日期查询订单
     * @param date 日期
     * @return 订单列表
     */
    @GetMapping("/date")
    public Result<List<Order>> getOrdersByDate(
            @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate date) {
        
        List<Order> orders = orderService.getOrdersByDate(date);
        return Result.success(orders);
    }
    
    /**
     * 根据订单状态查询订单
     * @param status 订单状态
     * @return 订单列表
     */
    @GetMapping("/status/{status}")
    public Result<List<Order>> getOrdersByStatus(@PathVariable String status) {
        List<Order> orders = orderService.getOrdersByStatus(status);
        return Result.success(orders);
    }
    
    /**
     * 根据用户ID和订单状态查询订单
     * @param userId 用户ID
     * @param status 订单状态
     * @return 订单列表
     */
    @GetMapping("/user/{userId}/status/{status}")
    public Result<List<Order>> getOrdersByUserIdAndStatus(
            @PathVariable Long userId, 
            @PathVariable String status) {
        List<Order> orders = orderService.getOrdersByUserIdAndStatus(userId, status);
        return Result.success(orders);
    }
    
    /**
     * 测试日期时间格式接口
     * @param orderData 订单数据
     * @return 订单数据
     */
    @PostMapping("/test-date-format")
    public Result<?> testDateFormat(@RequestBody Order orderData) {
        System.out.println("收到的测试数据: " + orderData);
        System.out.println("startTime: " + orderData.getStartTime());
        System.out.println("endTime: " + orderData.getEndTime());
        System.out.println("createTime: " + orderData.getCreateTime());
        System.out.println("updateTime: " + orderData.getUpdateTime());
        
        return Result.success(orderData);
    }
    
    /**
     * 标记订单为已使用状态
     * @param id 订单ID
     * @return 操作结果
     */
    @GetMapping("/mark-used")
    public Result<?> markOrderAsUsed(@RequestParam Long id) {
        try {
            boolean success = orderService.markOrderAsUsed(id);
            if (success) {
                return Result.success("订单已标记为已使用");
            } else {
                return Result.fail("标记失败，未找到订单");
            }
        } catch (Exception e) {
            return Result.fail("标记失败：" + e.getMessage());
        }
    }
} 